package org.lanyu.springainovel.common.util;

import org.lanyu.springainovel.common.entity.User;
import org.lanyu.springainovel.common.service.UserCacheService;
import org.lanyu.springainovel.common.service.UserService;
import org.springframework.stereotype.Component;

/**
 * 用户认证工具类
 * 提供用户认证、权限检查等功能
 * 依赖于SecurityContextUtil获取基础用户信息
 */
@Component
public class UserAuthUtil {

    private final UserService userService;
    private final UserCacheService userCacheService;

    public UserAuthUtil(UserService userService, UserCacheService userCacheService) {
        this.userService = userService;
        this.userCacheService = userCacheService;
    }

    /**
     * 获取当前认证的用户实体（从缓存或数据库）
     * 
     * @return 用户实体，如果用户未认证则返回null
     */
    public User getCurrentUser() {
        Long userId = SecurityContextUtil.getCurrentUserId();
        if (userId == null) {
            return null;
        }
        
        // 先从缓存获取
        User user = userCacheService.getUserById(userId);
        if (user == null) {
            // 缓存中没有则从数据库获取
            user = userService.getUserById(userId);
            if (user != null) {
                userCacheService.cacheUser(user);
            }
        }
        return user;
    }

    /**
     * 获取当前认证的用户实体（必须存在）
     * 
     * @return 用户实体
     * @throws IllegalStateException 如果用户未认证
     */
    public User getRequiredCurrentUser() {
        User user = getCurrentUser();
        if (user == null) {
            throw new IllegalStateException("用户未认证或用户信息不存在");
        }
        return user;
    }

    /**
     * 获取当前用户ID
     * 
     * @return 用户ID，如果用户未认证则返回null
     */
    public Long getCurrentUserId() {
        return SecurityContextUtil.getCurrentUserId();
    }

    /**
     * 获取当前用户ID（必须存在）
     * 
     * @return 用户ID
     * @throws IllegalStateException 如果用户未认证
     */
    public Long getRequiredCurrentUserId() {
        return SecurityContextUtil.getRequiredCurrentUserId();
    }

    /**
     * 获取当前用户名
     * 
     * @return 用户名，如果用户未认证则返回null
     */
    public String getCurrentUsername() {
        return SecurityContextUtil.getCurrentUsername();
    }

    /**
     * 获取当前用户昵称
     * 
     * @return 用户昵称，如果用户未认证则返回null
     */
    public String getCurrentNickname() {
        return SecurityContextUtil.getCurrentNickname();
    }

    /**
     * 检查当前用户是否已认证
     * 
     * @return 如果已认证返回true，否则返回false
     */
    public boolean isAuthenticated() {
        return SecurityContextUtil.isAuthenticated();
    }

    /**
     * 检查当前用户是否具有指定权限
     * 
     * @param permission 权限标识
     * @return 如果具有权限返回true，否则返回false
     */
    public boolean hasPermission(String permission) {
        if (!isAuthenticated()) {
            return false;
        }
        
        User user = getCurrentUser();
        if (user == null) {
            return false;
        }
        
        // 管理员拥有所有权限
        if ("ROLE_ADMIN".equals(user.getRole())) {
            return true;
        }
        
        // TODO: 实现具体的权限检查逻辑
        // 目前简单返回false，后续可以根据需要扩展
        return false;
    }

    /**
     * 检查当前用户是否具有指定权限（必须具有）
     * 
     * @param permission 权限标识
     * @throws IllegalStateException 如果用户未认证或不具有指定权限
     */
    public void checkPermission(String permission) {
        if (!hasPermission(permission)) {
            throw new IllegalStateException("用户不具有权限: " + permission);
        }
    }

    /**
     * 检查当前用户是否是管理员
     * 
     * @return 如果是管理员返回true，否则返回false
     */
    public boolean isAdmin() {
        if (!isAuthenticated()) {
            return false;
        }
        
        User user = getCurrentUser();
        return user != null && "ROLE_ADMIN".equals(user.getRole());
    }

    /**
     * 检查当前用户是否是管理员（必须是）
     * 
     * @throws IllegalStateException 如果用户未认证或不是管理员
     */
    public void checkAdmin() {
        if (!isAdmin()) {
            throw new IllegalStateException("用户不是管理员");
        }
    }
}
